home *** CD-ROM | disk | FTP | other *** search
/ CD ROM Paradise Collection 4 / CD ROM Paradise Collection 4 1995 Nov.iso / system / tlb_a251.zip / HIGHUMM.DOC < prev    next >
Text File  |  1994-09-14  |  24KB  |  663 lines
  1.  
  2.  
  3.         
  4.  
  5.  
  6.                    Application Program Interface Specification
  7.  
  8.                                        for
  9.  
  10.                                    HIGHUMM.SYS
  11.  
  12.                                        of
  13.  
  14.                         THE LAST BYTE MEMORY MANAGER (tm)
  15.  
  16.  
  17.  
  18.  
  19.                                   Version 2.51
  20.  
  21.  
  22.  
  23.  
  24.  
  25.  
  26.  
  27.  
  28.  
  29.  
  30.                               Copyright (C) 1990-94
  31.                                All Rights Reserved
  32.  
  33.  
  34.                                        by
  35.  
  36.  
  37.                               KEY SOFTWARE PRODUCTS
  38.  
  39.                                 440 Ninth Avenue
  40.                         Menlo Park, California 94025-1802
  41.                                   415-364-9847
  42.  
  43.  
  44.  
  45.  
  46.  
  47.  
  48.  
  49.  
  50.  
  51.  
  52.  
  53.  
  54.  
  55.  
  56.         The Last Byte Memory Manager is a trademark of Key Software Products
  57.  
  58.  
  59.  
  60.         
  61.  
  62.  
  63.                                 TABLE OF CONTENTS
  64.  
  65.  
  66.  
  67.         CHAPTER 1 - APPLICATION PROGRAM INTERFACE TO HIGHUMM.SYS       1
  68.            1.1  XMS Upper Memory Blocks     .......................    1
  69.            1.2  Bank-Switch Memory       ..........................    3
  70.            1.3  Summary Of HIGHUMM.SYS Functions     ..............    5
  71.               1.3.1  Function 0: Request a UMB memory block  ......    5
  72.               1.3.2  Function 1: Release a UMB memory block  ......    6
  73.               1.3.3  Function 2: Request a Bank-Switch memory block    6
  74.               1.3.4  Function 3: Release a Bank-Switch memory block    6
  75.               1.3.5  Function 4: Transfer data to/from high memory     6
  76.               1.3.6  Function 5: Get a Word from a Bank-Switch bloc    7
  77.               1.3.7  Function 6: Put a Word to a Bank-Switch block.    7
  78.               1.3.8  Function 7: Put a Byte to a Bank-Switch block.    7
  79.               1.3.9  Function 8: Enable Bank-Switch Memory    .....    7
  80.               1.3.10  Function 9: Disable Bank-Switch Memory    ...    8
  81.               1.3.11  Function 10: Assign a name to a UMB or.......    8
  82.               1.3.12  Function 11: Locate a UMB block by name .....    8
  83.               1.3.13  Function 12: Locate a BSW block by name .....    8
  84.               1.3.14  Function 13: Resize a UMB block   ...........    9
  85.            1.4  Final Notes       .................................    9
  86.  
  87.  
  88.  
  89.  
  90.  
  91.  
  92.  
  93.  
  94.  
  95.  
  96.  
  97.  
  98.  
  99.  
  100.  
  101.  
  102.  
  103.  
  104.  
  105.  
  106.  
  107.  
  108.  
  109.  
  110.  
  111.  
  112.  
  113.  
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120.         
  121.  
  122.  
  123.  
  124.         Sep 14, 1994  Programmer's Interface to HIGHUMM.SYS             1
  125.  
  126.  
  127.           CHAPTER 1 - APPLICATION PROGRAM INTERFACE TO HIGHUMM.SYS    
  128.  
  129.  
  130.         HIGHUMM.SYS  is a device driver that lets application programmers
  131.         access  upper  memory  between  640k  and 1Meg.  It requires that
  132.         LASTBYTE  be installed first, and automatically loads itself into
  133.         upper  memory  without the need to use either HIGHDRVR or the DOS
  134.         5 DEVICEHIGH command.  
  135.  
  136.         HIGHUMM provides two methods of accessing high memory: 
  137.  
  138.  
  139.         1.1 XMS Upper Memory Blocks      
  140.  
  141.         If  an  Extended  Memory  Specification  (XMS)  driver  (such  as
  142.         HIMEM.SYS)  has  already  been loaded, HIGHUMM will link into it,
  143.         providing   an  implementation  of  the  two  XMS  functions  for
  144.         accessing  what  the XMS specification refers to as "Upper Memory
  145.         Blocks"  (UMB's).   Although  described in the XMS specification,
  146.         the  UMB functions have not been implemented in the current (June
  147.         1990) and previous versions of HIMEM.SYS.  
  148.  
  149.         If  an XMS driver has not been loaded, then HIGHUMM will become a
  150.         UMB-Only  XMS  device driver, providing support for XMS functions
  151.         00h   (Get   Version  Number),  10h  (Allocate  UMB  Block),  11h
  152.         (Deallocate  UMB  Block).   All  other  XMS functions will return
  153.         failure, indicating that the function is not implemented.  
  154.  
  155.                 ┌─────────────────────────────────────────────────┐
  156.                 │ If another XMS device driver is used (e.g., to  │
  157.                 │ provide management of Extended Memory or the    │
  158.                 │ High Memory Area), it must be loaded before     │
  159.                 │ HIGHUMM.SYS.                                    │ 
  160.                 └─────────────────────────────────────────────────┘ 
  161.  
  162.         Upper  Memory  Blocks  (UMBs)  are  blocks of memory available on
  163.         some  80x86  based  machines which are located between DOS's 640K
  164.         limit  and  the  1MB  address  boundary.   The  number, size, and
  165.         location  of these blocks vary widely depending upon the types of
  166.         hardware  adapter cards installed in the machine.  By definition,
  167.         this   memory   is  DOS-accessible,  but  does  NOT  include  the
  168.         Bank-Switch memory supported by LASTBYTE.  
  169.  
  170.         On  80286  and  80386  based machines, XMS allows DOS programs to
  171.         utilize  Extended  Memory  in  a  consistent, machine independent
  172.         manner.   With some restrictions, XMS adds almost 64K of Extended
  173.         Memory  to  the  640K  which  DOS  programs  can access directly.
  174.         Depending  on  available  hardware,  XMS  may  provide  even more
  175.         memory  (UMB's)  to DOS programs.  XMS also provides DOS programs
  176.         with a standard method of storing data in Extended Memory.  
  177.  
  178.  
  179.  
  180.  
  181.         Copyright (C) 1990-94, Key Software Products. All Rights Reserved
  182.  
  183.  
  184.         Sep 14, 1994  Programmer's Interface to HIGHUMM.SYS             2
  185.  
  186.  
  187.         The  XMS Specification for MS-DOS was jointly developed by Lotus,
  188.         Intel,  Microsoft,  and  AST  Research.   The  specification  was
  189.         published  on July 19, 1988 and released to the public domain and
  190.         is  not  confidential  or  proprietary,  but the specification is
  191.         still  the  copyright  and  property of these companies.  You may
  192.         obtain  a copy from Microsoft Corporation, 16011 NE 36th Way, Box
  193.         97017,  Redmond,  WA  98073,  or  by  calling  Microsoft at (800)
  194.         426-9400.  
  195.  
  196.         Access to the UMB's through XMS is a four step process: 
  197.  
  198.                 1.  Test for the existence of the XMS driver.  
  199.                 2.  Obtain the address of the XMS control function.  
  200.                 3.  Invoke the Request UMB or Release UMB function.  
  201.                 4.  Check for success or failure.  
  202.  
  203.         This is best explained by an example: 
  204.  
  205.                 ...  
  206.                 mov     ax,4300h        ; XMS driver installed? 
  207.                 int     2Fh 
  208.                 cmp     al,80h 
  209.                 jne     NoXMSDriver 
  210.                 ...  
  211.                 mov     ax,4310h        ; Get adrs of XMS Ctl Func 
  212.                 int     2Fh 
  213.                 mov     WORD PTR [XMSControl],bx 
  214.                 mov     WORD PTR [XMSControl+2],es 
  215.                 ...  
  216.                 mov     ah,10h          ; Request a UMB memory block 
  217.                 mov     dx,size_in_paragraphs 
  218.                 call    [XMSControl]    ; a FAR call! 
  219.                 cmp     ax,1 
  220.                 jne     Request_Failed 
  221.  
  222.                 ; If request was successful: 
  223.                 ; -------------------------- 
  224.                 ; AX = 1 
  225.                 ; BX = Segment address of allocated block 
  226.                 ; DX = Actual size of block (same as requested size) 
  227.  
  228.                 ; If request failed: 
  229.                 ; ------------------ 
  230.                 ; AX = 0 
  231.                 ; DX = size of largest available in paragraphs 
  232.                 ; Error Codes:  BL = 80h (Not implemented/installed) 
  233.                 ;               BL = B0h (Smaller UMB available) 
  234.                 ;               BL = B1h (No UMB available) 
  235.  
  236.                 mov     ah,11h          ; Resize a UMB memory block 
  237.                 mov     bx,new_size_in_paragraphs 
  238.  
  239.  
  240.  
  241.         Copyright (C) 1990-94, Key Software Products. All Rights Reserved
  242.  
  243.  
  244.         Sep 14, 1994  Programmer's Interface to HIGHUMM.SYS             3
  245.  
  246.  
  247.                 mov     dx,paragraph_address_of_umb_block 
  248.                 call    [XMSControl]    ; a FAR call! 
  249.                 cmp     ax,1 
  250.                 jne     Request_Failed 
  251.  
  252.                 ; If request was successful: 
  253.                 ; -------------------------- 
  254.                 ; AX = 1 
  255.                 ; BX = Segment address of reallocated block 
  256.                 ; DX = Actual size of block (same as requested size) 
  257.  
  258.                 ; If request failed: 
  259.                 ; ------------------ 
  260.                 ; AX = 0 
  261.                 ; DX = size of largest available in paragraphs 
  262.                 ; Error Codes:  BL = 80h (Not implemented/installed) 
  263.                 ;               BL = B0h (Smaller UMB available) 
  264.                 ;               BL = B1h (No UMB available) 
  265.  
  266.                 mov     ah,11h          ; Release a UMB memory block 
  267.                 mov     dx,segment_address_of_umb 
  268.                 call    [XMSControl]    ; a FAR call! 
  269.                 cmp     ax,1 
  270.                 jne     Release_Failed 
  271.  
  272.                 ; If request was successful: 
  273.                 ; -------------------------- 
  274.                 ; AX = 1 
  275.  
  276.                 ; If request failed: 
  277.                 ; ------------------ 
  278.                 ; AX = 0 
  279.                 ; Error Codes:  BL = 80h (Not implemented/installed) 
  280.                 ;               BL = B2h (invalid segment number) 
  281.  
  282.  
  283.         HIGHMEM lists such UMB memory blocks as "MS-DOS XMS UMB".  
  284.  
  285.  
  286.         1.2 Bank-Switch Memory        
  287.  
  288.         The  second  method  of  accessing  high memory is by opening the
  289.         device  "KSP$UMM"  and  performing  an  IOCTL Read of four bytes.
  290.         This  obtains  the  offset and segment address of an extended UMB
  291.         control  function  that  provides access to Bank-Switch memory as
  292.         well  as  normal  UMB  blocks.   Using HIGHUMM.SYS in this manner
  293.         does  not  require  that  an  XMS  driver  such  as  HIMEM.SYS be
  294.         loaded.  For example: 
  295.  
  296.  
  297.         Device_Name     db     'KSP$UMM',0   ;  HIGHUMM.SYS  device  name
  298.  
  299.  
  300.  
  301.         Copyright (C) 1990-94, Key Software Products. All Rights Reserved
  302.  
  303.  
  304.         Sep 14, 1994  Programmer's Interface to HIGHUMM.SYS             4
  305.  
  306.  
  307.         HIGHUMM_Ctl   dw   0,0         ; far ptr to ctl func 
  308.  
  309.                 ...  
  310.                 mov     ax,3D00h        ; open file or device 
  311.                 mov     dx,OFFSET Device_Name   ; DS:DX => device name 
  312.                 int     21h 
  313.                 jc      Open_Failed     ; (HIGHUMM.SYS not installed) 
  314.                 mov     handle,ax       ; save handle 
  315.  
  316.                 mov     ax,4400h        ; ioctl: get device attributes 
  317.                 mov     bx,handle 
  318.                 int     21h 
  319.                 jc      Attb_Failed     ; (HIGHUMM.SYS not functioning) 
  320.                 test    dl,80h          ; is this a device or a filename 
  321.                 jz      Not_Device      ; File called "KSP$UMM" exists! 
  322.  
  323.                 mov     ax,4402h        ; IOCTL Read (BX = handle) 
  324.                 mov     bx,handle 
  325.                 mov     dx,OFFSET HIGHUMM_Ctl   ; DS:DX => read buffer 
  326.                 mov     cx,4            ; read *EXACTLY* four bytes 
  327.                 int     21h 
  328.  
  329.                 pushf 
  330.                 mov     ah,3Eh          ; Close device (BX = handle) 
  331.                 mov     bx,handle 
  332.                 int     21h 
  333.                 popf 
  334.  
  335.                 jc      IOCTL_Error     ; (HIGHUMM.SYS not functioning) 
  336.  
  337.                 ; Offset of control function is in "HIGHUMM_Ctl" 
  338.                 ; Segment of control function is in "HIGHUMM_Ctl+2" 
  339.  
  340.  
  341.         Once  you  have the address of the extended control function from
  342.         HIGHUMM.SYS, you can invoke any of the following 13 functions: 
  343.  
  344.                 Function        Description                     Class 
  345.                 --------        -----------                     -------- 
  346.                 AH = 0  Request a UMB memory block              STANDARD 
  347.                 AH = 1  Release a UMB memory block              STANDARD 
  348.                 AH = 2  Request a Bank-Switch memory block      EXTRA 
  349.                 AH = 3  Release a Bank-Switch memory block      EXTRA 
  350.                 AH = 4  Transfer data to/from high memory       EXTRA 
  351.                 AH = 5  Get a Word from a Bank-Switch block     EXTRA 
  352.                 AH = 6  Put a Word to a Bank-Switch block       EXTRA 
  353.                 AH = 7  Put a Byte to a Bank-Switch block       EXTRA 
  354.                 AH = 8  Enable Bank-Switch Memory               EXTRA 
  355.                 AH = 9  Disable Bank-Switch Memory              EXTRA 
  356.                 AH = A  Assign a name to a UMB or BSW block     EXTRA 
  357.                 AH = B  Locate a UMB block by name              EXTRA 
  358.  
  359.  
  360.  
  361.         Copyright (C) 1990-94, Key Software Products. All Rights Reserved
  362.  
  363.  
  364.         Sep 14, 1994  Programmer's Interface to HIGHUMM.SYS             5
  365.  
  366.  
  367.                 AH = C  Locate a BSW block by name              EXTRA 
  368.                 AH = D  Resize a UMB memory block               STANDARD 
  369.  
  370.                 ┌─────────────────────────────────────────────────┐
  371.                 │ Support for the "EXTRA" class of functions      │
  372.                 │ requires use of the "/EXTRA" option on the      │
  373.                 │ HIGHUMM.SYS command line:                       │
  374.                 └─────────────────────────────────────────────────┘ 
  375.  
  376.                 DEVICE=C:\TLBMM\HIGHUMM.SYS /EXTRA 
  377.  
  378.                 ("/EXTRA" may be abbreviated as simply "/E".) 
  379.  
  380.         These  function  numbers  are  different  than  those  used  with
  381.         XMSControl  even though three of them are otherwise equivalent to
  382.         XMS  functions 10h and 11h!  Calling one of the HIGHUMM functions
  383.         is  similar  to  calling  the  XMS  functions.   For  example, to
  384.         request  a  Bank-Switch memory block, the following code would be
  385.         used:  
  386.  
  387.                 mov     ah,2                    ; Request a BSW block 
  388.                 mov     dx,paragraphs 
  389.                 call    [HIGHUMM_Control]       ; a FAR call! 
  390.                 cmp     ax,1 
  391.                 jne     Request_Failed          ; BL contains error code 
  392.                                                 ; DX = largest available 
  393.  
  394.                 ; Success: BX contains segment number 
  395.  
  396.         For  all  HIGHUMM.SYS  functions, the error codes are the same as
  397.         returned by the XMS driver: 
  398.  
  399.                 AX = 0001h      Function successful 
  400.                      0000h      Function failed; error code in BL 
  401.  
  402.                 BL = 80h        Function not implemented 
  403.                      B0h        Insuf. memory; smaller block available 
  404.                      B1h        Insuf. memory; no block available 
  405.                      B2h        Invalid block segment number 
  406.  
  407.  
  408.         1.3 Summary Of HIGHUMM.SYS Functions      
  409.  
  410.         1.3.1 Function 0: Request a UMB memory block  
  411.  
  412.              Parameters:     AH = 0 (same as XMS function AH=10h)
  413.                              DX = Size of requested block in paragraphs
  414.  
  415.              Returns:        AX = Status
  416.                              BX = Segment Number or Error Code
  417.                              DX = Size of requested block/largest block
  418.  
  419.  
  420.  
  421.         Copyright (C) 1990-94, Key Software Products. All Rights Reserved
  422.  
  423.  
  424.         Sep 14, 1994  Programmer's Interface to HIGHUMM.SYS             6
  425.  
  426.  
  427.  
  428.              Description:    Identical to XMS function 10h
  429.  
  430.  
  431.         1.3.2 Function 1: Release a UMB memory block  
  432.  
  433.              Parameters:     AH = 1 (same as XMS function AH=11h)
  434.                              DX = Segment number of memory block
  435.  
  436.              Returns:        AX = Status
  437.                              BL = Error Code
  438.  
  439.              Description:    Identical to XMS function 11h
  440.  
  441.  
  442.         1.3.3 Function 2: Request a Bank-Switch memory block  
  443.  
  444.              Parameters:     AH = 2
  445.                              DX = Size of requested block in paragraphs
  446.  
  447.              Returns:        AX = Status
  448.                              BX = Segment Number or Error Code
  449.                              DX = Size of requested block/largest block
  450.  
  451.              Description:    Similar to function 0 for regular UMB blocks,
  452.                              except that HIGHMEM lists these blocks as
  453.                              "Bank-Switch UMB".
  454.  
  455.  
  456.         1.3.4 Function 3: Release a Bank-Switch memory block  
  457.  
  458.              Parameters:     AH = 3
  459.                              DX = Segment number of memory block
  460.  
  461.              Returns:        AX = Status
  462.                              BL = Error Code
  463.  
  464.              Description:    Similar to function 1 for regular UMB blocks.
  465.  
  466.  
  467.         1.3.5 Function 4: Transfer data to/from high memory  
  468.  
  469.              Parameters:     AH = 4
  470.                              DS:SI = Segment:Offset of source
  471.                              ES:DI = Segment:Offset of destination
  472.                              CX = byte count
  473.  
  474.              Returns:        AX = Status (Never returns failure)
  475.  
  476.              Description:    Enables Bank-Switch Memory, copies data between
  477.                              the specified source and destination, then
  478.  
  479.  
  480.  
  481.         Copyright (C) 1990-94, Key Software Products. All Rights Reserved
  482.  
  483.  
  484.         Sep 14, 1994  Programmer's Interface to HIGHUMM.SYS             7
  485.  
  486.  
  487.                              disables Bank-Switch memory.
  488.  
  489.  
  490.         1.3.6 Function 5: Get a Word from a Bank-Switch block
  491.  
  492.              Parameters:     AH = 5
  493.                              ES:DI = Segment:Offset of word to read
  494.  
  495.              Returns:        AX = Status (Never returns failure)
  496.                              DX = WORD from BSW Block
  497.  
  498.              Description:    Enables Bank-Switch Memory, loads DX from the
  499.                              specified location, then disables Bank-Switch
  500.                              memory.
  501.  
  502.  
  503.         1.3.7 Function 6: Put a Word to a Bank-Switch block
  504.  
  505.              Parameters:     AH = 6
  506.                              DX = Word to put into BSW Block
  507.                              ES:DI = Segment:Offset of word to write
  508.  
  509.              Returns:        AX = Status (Never returns failure)
  510.  
  511.              Description:    Enables Bank-Switch Memory, stores DX into the
  512.                              specified location, then disables Bank-Switch
  513.                              memory.
  514.  
  515.  
  516.         1.3.8 Function 7: Put a Byte to a Bank-Switch block
  517.  
  518.              Parameters:     AH = 7
  519.                              DL = Byte to put into BSW Block
  520.                              ES:DI = Segment:Offset of byte to write
  521.  
  522.              Returns:        AX = Status (Never returns failure)
  523.  
  524.              Description:    Enables Bank-Switch Memory, stores DL into the
  525.                              specified location, then disables Bank-Switch
  526.                              memory.
  527.  
  528.  
  529.         1.3.9 Function 8: Enable Bank-Switch Memory    
  530.  
  531.              Parameters:     AH = 8
  532.                              DS:SI = Segment:Offset of 6-byte save area
  533.  
  534.              Returns:        AX = Status (Never returns failure)
  535.  
  536.              Description:    Disables interrupts, saves the memory controller
  537.                              state in a 6-byte save area within the 
  538.  
  539.  
  540.  
  541.         Copyright (C) 1990-94, Key Software Products. All Rights Reserved
  542.  
  543.  
  544.         Sep 14, 1994  Programmer's Interface to HIGHUMM.SYS             8
  545.  
  546.  
  547.                              application program, and enables Bank-Switch
  548.                              memory so that data within it may be accessed.
  549.  
  550.  
  551.         1.3.10 Function 9: Disable Bank-Switch Memory    
  552.  
  553.              Parameters:     AH = 9
  554.                              DS:SI = Segment:Offset of 6-byte save area
  555.  
  556.              Returns:        AX = Status (Never returns failure)
  557.  
  558.              Description:    Reloads the state of the memory controller from a
  559.                              6-byte save area in the application program and
  560.                              restores the previous interrupt enable status.
  561.  
  562.  
  563.         1.3.11 Function 10: Assign a name to a UMB or
  564.  
  565.              Parameters:     AH = 0Ah
  566.                              DX = Segment number of memory block
  567.                              DS:SI = Segment:Offset of 8-byte blank-padded
  568.                                      name
  569.  
  570.              Returns:        AX = Status
  571.                              BX = Error Code
  572.  
  573.              Description:    Copies 8 bytes to the name field of the
  574.                              allocated UMB or BSW memory block.
  575.  
  576.  
  577.         1.3.12 Function 11: Locate a UMB block by name 
  578.  
  579.              Parameters:     AH = 0Bh
  580.                              DS:SI = Segment:Offset of 8-byte blank-padded
  581.                                      name
  582.  
  583.              Returns:        AX = Status
  584.                              BX = Segment Number or Error Code
  585.                              DX = Size of block
  586.  
  587.              Description:    Locates a UMB memory block by its 1-8 character
  588.                              name.  All 8 bytes of name are compared; letter
  589.                              with different case do not match.
  590.  
  591.  
  592.         1.3.13 Function 12: Locate a BSW block by name 
  593.  
  594.              Parameters:     AH = 0Ch
  595.                              DS:SI = Segment:Offset of 8-byte blank-padded
  596.                                      name
  597.  
  598.  
  599.  
  600.  
  601.         Copyright (C) 1990-94, Key Software Products. All Rights Reserved
  602.  
  603.  
  604.         Sep 14, 1994  Programmer's Interface to HIGHUMM.SYS             9
  605.  
  606.  
  607.              Returns:        AX = Status
  608.                              BX = Segment Number or Error Code
  609.                              DX = Size of block
  610.  
  611.              Description:    Locates a BSW memory block by its 1-8 character
  612.                              name.  All 8 bytes of name are compared; letter
  613.                              with different case do not match.
  614.  
  615.  
  616.         1.3.14 Function 13: Resize a UMB block   
  617.  
  618.              Parameters:     AH = 0Dh (same as XMS function AH=12h)
  619.                              BX = new size of UMB block in paragraphs
  620.                              DX = segment number of memory block to resize
  621.  
  622.              Returns:        AX = Status
  623.                              BX = Segment Number or Error Code
  624.  
  625.              Description:    Attempts to change the size of a previously 
  626.                              allocated UMB memory block.
  627.  
  628.  
  629.         IMPORTANT!  A  call  to  function 8 must be followed by a call to
  630.         function  9, and without enabling interrupts in between.  This is
  631.         because  while  Bank-Switch  memory  is enabled, all adapter RAMs
  632.         (including  display  buffers) and any ROMs which are not shadowed
  633.         are  disabled;  thus  any  code (either your own program or a TSR
  634.         activated  by  the  timer  tick)  that  attempts  to access these
  635.         resources  will fail.  Also, it is important to execute this code
  636.         quickly  to  minimize  the  amount  of  time  that interrupts are
  637.         disabled.  
  638.  
  639.  
  640.         1.4 Final Notes        
  641.  
  642.         The  only valid use of Bank-Switch memory is to store data! Never
  643.         load  a program into Bank-Switch memory and then reference it via
  644.         a  JMP  or  CALL  -  it won't be there!  For example, you may NOT
  645.         load   a  TSR  into  Bank-Switch  memory  and  expect  it  to  be
  646.         accessible when it's activating interrupt occurs.  
  647.  
  648.         UMB's  (regular  and  Bank-Switched) are NOT automatically free'd
  649.         at  program  termination  like  regular  memory allocated by your
  650.         program  using  DOS  function  72 (48 hex).  For example, if your
  651.         program  uses  a  UMB for a temporary buffer, you must be sure to
  652.         release the UMB before terminating the program.  
  653.  
  654.  
  655.  
  656.  
  657.  
  658.  
  659.  
  660.  
  661.         Copyright (C) 1990-94, Key Software Products. All Rights Reserved
  662.  
  663.